package com.by.wx.redis;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson2.JSON;
import lombok.AllArgsConstructor;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * @Author 陈子杰
 * @Description Redis操作管理类
 * @Version 1.0.0
 * @Date 2024/9/27 16:18
 */
@Component
@SuppressWarnings(value = {"unchecked", "rawtypes"})
@AllArgsConstructor
public class RedisManage {
    private final RedisTemplate redisTemplate;

    /**
     * 如果为空则设置值
     *
     * @param key     key
     * @param timeout 过期时间
     * @param unit    时间单位
     * @return 设置成功:true,失败:false
     */
    public Boolean setNx(String key, long timeout, TimeUnit unit) {
        return redisTemplate.opsForValue().setIfAbsent(key, "", timeout, unit);
    }

    /**
     * 删除
     *
     * @param prefix key
     * @return {@link Boolean}
     */
    public void delete(final String prefix) {
        Set<String> keys = keys(prefix);
        redisTemplate.delete(keys);
    }

    /**
     * 批量删除
     */
    public void delete(Collection<String> keys) {
        redisTemplate.delete(keys);
    }

    /**
     * 设置过期时间
     */
    public Boolean expire(String key, long timeout, TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 设置过期时间
     */
    public Boolean expireAt(String key, Date date) {
        return redisTemplate.expireAt(key, date);
    }

    /**
     * 移除key的过期时间
     */
    public Boolean persist(String key) {
        return redisTemplate.persist(key);
    }

    /**
     * 返回key剩余的过期时间
     */
    public Long getExpire(String key, TimeUnit unit) {
        return redisTemplate.getExpire(key, unit);
    }

    /**
     * 返回key剩余的过期时间
     */
    public Long getExpire(String key) {
        return redisTemplate.getExpire(key);
    }

    /**
     * 设置值
     */
    public <T> void set(final String key, final T value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 设置值并设置过期时间
     */
    public <T> void set(final String key, final T value, Long time, TimeUnit unit) {
        redisTemplate.opsForValue().set(key, value, time, unit);
    }

    /**
     * 批量设置值
     */
    public void multiSet(Map<String, String> maps) {
        redisTemplate.opsForValue().multiSet(maps);
    }

    /**
     * 修改key名称
     */
    public void rename(String oldKey, String newKey) {
        redisTemplate.rename(oldKey, newKey);
    }

    /**
     * 获取所有key
     */
    public Set<String> keys(String prefix) {
        if (StrUtil.isBlank(prefix)) {
            prefix = "*";
        }
        return redisTemplate.keys(prefix);
    }

    /**
     * 获取值
     */
    public <T> T get(String key) {
        return (T) redisTemplate.opsForValue().get(key);
    }

    /**
     * 获取值
     */
    public <T> T get(String key, Class<T> clazz) {
        Object t = redisTemplate.opsForValue().get(key);
        String jsonString = JSON.toJSONString(t);
        return JSON.parseObject(jsonString, clazz);
    }

    /**
     * 获取数组
     *
     * @param key    key
     * @param classz 对象类型
     * @return list对象
     */
//    public <T> List<T> getList(final String key, Class<T> classz) {
//        Object object = redisTemplate.opsForValue().get(key);
//        if (ObjUtil.isNotEmpty(object)) {
//            String jsonString = JSON.toJSONString(object);
//            List<T> list = JSON.parseArray(jsonString, classz);
//            return list;
//        }
//        return null;
//    }

    /**
     * 根据前缀获取值
     *
     * @param prefix 前缀
     * @return {@link List }<{@link T }>
     */
    public <T> List<T> getList(String prefix, Class<T> classz) {
        List<T> list = new ArrayList<>();
        Set<String> keys = keys(prefix);
        if (CollectionUtil.isEmpty(keys)) {
            return list;
        }
        for (String key : keys) {
            T t = get(key);
            if (ObjectUtil.isNotNull(t)) {
                String jsonString = JSON.toJSONString(t);
                list.add(JSON.parseObject(jsonString, classz));
            }
        }
        return list;
    }

    /**
     * 批量获取值
     */
    public List<String> multiGet(Collection<String> keys) {
        return redisTemplate.opsForValue().multiGet(keys);
    }

    /**
     * 判断是否存在
     */
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 移动当前key到指定的数据库db中
     */
    public Boolean move(String key, Integer dbIndex) {
        return redisTemplate.move(key, dbIndex);
    }

    /**
     * 自增长,负数则为自减
     */
    public Long incrBy(String key, long increment) {
        return redisTemplate.opsForValue().increment(key, increment);
    }

    /**
     * 自减
     */
    public Long decrBy(String key, long decrement) {
        return redisTemplate.opsForValue().decrement(key, decrement);
    }
}
